home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / asxsrc.arc / ASLIST.C < prev    next >
C/C++ Source or Header  |  1991-06-10  |  6KB  |  364 lines
  1. /* aslist.c */
  2.  
  3. /*
  4.  * (C) Copyright 1989
  5.  * All Rights Reserved
  6.  *
  7.  * Alan R. Baldwin
  8.  * 721 Berkeley St.
  9.  * Kent, Ohio  44240
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <setjmp.h>
  14. #include "asm.h"
  15.  
  16. /*
  17.  * Copy a block of source and code to
  18.  * the listing file. If no listing file or
  19.  * the current line is not to be listed
  20.  * just return. Multiple code bytes get
  21.  * put out on extra lines after the source
  22.  * line.
  23.  */
  24. VOID
  25. list()
  26. {
  27.     register char *wp;
  28.     register nb;
  29.  
  30.     if (lfp == NULL || lmode == NLIST)
  31.         return;
  32.     slew(lfp);
  33.     while (ep < &eb[NERR])
  34.         *ep++ = ' ';
  35.     fprintf(lfp, "%.2s", eb);
  36.     if (lmode == SLIST) {
  37.         fprintf(lfp, "%24s%5u %s\n", "", line, ib);
  38.         return;
  39.     }
  40.     if (xflag == 0) {        /* HEX */
  41.         fprintf(lfp, " %04X", laddr);
  42.         if (lmode == ALIST) {
  43.             fprintf(lfp, "%19s%5u %s\n", "", line, ib);
  44.             return;
  45.         }
  46.         wp = cb;
  47.         nb = cp - cb;
  48.         list1(wp, nb, 1);
  49.         fprintf(lfp, " %5u %s\n", line, ib);
  50.         while ((nb -= 6) > 0) {
  51.             wp += 6;
  52.             slew(lfp);
  53.             fprintf(lfp, "%7s", "");
  54.             list1(wp, nb, 0);
  55.             putc('\n', lfp);
  56.         }
  57.     } else
  58.     if (xflag == 1) {        /* OCTAL */
  59.         fprintf(lfp, " %06o", laddr);
  60.         if (lmode == ALIST) {
  61.             fprintf(lfp, "%17s%5u %s\n", "", line, ib);
  62.             return;
  63.         }
  64.         wp = cb;
  65.         nb = cp - cb;
  66.         list1(wp, nb, 1);
  67.         fprintf(lfp, " %5u %s\n", line, ib);
  68.         while ((nb -= 4) > 0) {
  69.             wp += 4;
  70.             slew(lfp);
  71.             fprintf(lfp, "%9s", "");
  72.             list1(wp, nb, 0);
  73.             putc('\n', lfp);
  74.         }
  75.     } else
  76.     if (xflag == 2) {        /* DECIMAL */
  77.         fprintf(lfp, "  %05u", laddr);
  78.         if (lmode == ALIST) {
  79.             fprintf(lfp, "%17s%5u %s\n", "", line, ib);
  80.             return;
  81.         }
  82.         wp = cb;
  83.         nb = cp - cb;
  84.         list1(wp, nb, 1);
  85.         fprintf(lfp, " %5u %s\n", line, ib);
  86.         while ((nb -= 4) > 0) {
  87.             wp += 4;
  88.             slew(lfp);
  89.             fprintf(lfp, "%9s", "");
  90.             list1(wp, nb, 0);
  91.             putc('\n', lfp);
  92.         }
  93.     }
  94. }
  95.  
  96. /*
  97.  * Send bytes of code to the listing.
  98.  * A subroutine of `list'.
  99.  */
  100. VOID
  101. list1(wp, nb, f)
  102. register char *wp;
  103. register nb;
  104. {
  105.     register i;
  106.  
  107.     if (xflag == 0) {        /* HEX */
  108.     if (nb > 6)
  109.         nb = 6;
  110.     for (i=0; i<nb; ++i)
  111.         fprintf(lfp, " %02X", (*wp++)&0377);
  112.     if (f)
  113.         while (i < 6) {
  114.             fprintf(lfp, "   ");
  115.             ++i;
  116.         }
  117.     } else
  118.     if (xflag == 1) {        /* OCTAL */
  119.     if (nb > 4)
  120.         nb = 4;
  121.     for (i=0; i<nb; ++i)
  122.         fprintf(lfp, " %03o", (*wp++)&0377);
  123.     if (f)
  124.         while (i < 4) {
  125.             fprintf(lfp, "    ");
  126.             ++i;
  127.         }
  128.     } else
  129.     if (xflag == 2) {        /* DECIMAL */
  130.     if (nb > 4)
  131.         nb = 4;
  132.     for (i=0; i<nb; ++i)
  133.         fprintf(lfp, " %03u", (*wp++)&0377);
  134.     if (f)
  135.         while (i < 4) {
  136.             fprintf(lfp, "    ");
  137.             ++i;
  138.         }
  139.     }
  140. }
  141.  
  142. /*
  143.  * Increment the count of lines on the
  144.  * page. If the page overflows:
  145.  * 1) put out a page skip,
  146.  * 2) a title,
  147.  * 3) a subtitle,
  148.  * 4) and reset the line count.
  149.  */
  150. VOID
  151. slew(fp)
  152. FILE *fp;
  153. {
  154.     if (lop++ >= NLPP) {
  155.         fprintf(fp, "\fAssembler (%s), page %u.\n", cpu, ++page);
  156.         fprintf(fp, "%s\n", tb);
  157.         fprintf(fp, "%s\n\n", stb);
  158.         lop = 5;
  159.     }
  160. }
  161.  
  162. /*
  163.  * Symbol and Area Table Output
  164.  */
  165. VOID
  166. lstsym(fp)
  167. FILE *fp;
  168. {
  169.     register c, i, j, k;
  170.     register char *ptr;
  171.     int nmsym, narea;
  172.     struct sym *sp;
  173.     struct sym **p;
  174.     struct area *ap;
  175.  
  176.     /*
  177.      * Symbol Table Header
  178.      */
  179.     strcpy(stb, &symtbl[0]);
  180.     lop = NLPP;
  181.     if (fp == tfp)
  182.         page = 0;
  183.     slew(fp);
  184.  
  185.     /*
  186.      * Find number of symbols
  187.      */
  188.     nmsym = 0;
  189.     for (i=0; i<NHASH; i++) {
  190.         sp = symhash[i];
  191.         while (sp) {
  192.             if (sp != dot)
  193.                 ++nmsym;
  194.             sp = sp->s_sp;
  195.         }
  196.     }
  197.  
  198.     /*
  199.      * Allocate space for an array of pointers to symbols
  200.      * and load array.
  201.      */
  202.     if ((p = (struct sym **) malloc(sizeof((struct sym *) sp)*nmsym))
  203.         == NULL) {
  204.         fprintf(fp, "Insufficient space to build Symbol Table.\n");
  205.         return;
  206.     }
  207.     nmsym = 0;
  208.     for (i=0; i<NHASH; i++) {
  209.         sp = symhash[i];
  210.         while (sp) {
  211.             if (sp != dot)
  212.                 p[nmsym++] = sp;
  213.             sp = sp->s_sp;
  214.         }
  215.     }
  216.  
  217.     /*
  218.      * Bubble Sort on Symbol Table Array
  219.      */
  220.     j = 1;
  221.     c = nmsym - 1;
  222.     while (j) {
  223.         j = 0;
  224.         for (i=0; i<c; ++i) {
  225.             if (strcmp(&p[i]->s_id[0],&p[i+1]->s_id[0]) > 0) {
  226.                 j = 1;
  227.                 sp = p[i+1];
  228.                 p[i+1] = p[i];
  229.                 p[i] = sp;
  230.             }
  231.         }
  232.     }
  233.  
  234.     /*
  235.      * Symbol Table Output
  236.      */
  237.     for (i=0; i<nmsym;) {
  238.         sp = p[i];
  239.         if (sp->s_area) {
  240.             j = sp->s_area->a_ref;
  241.             if (xflag == 0) {
  242.                 fprintf(fp, " %2X ", j);
  243.             } else
  244.             if (xflag == 1) {
  245.                 fprintf(fp, "%3o ", j);
  246.             } else
  247.             if (xflag == 2) {
  248.                 fprintf(fp, "%3u ", j);
  249.             }
  250.         } else {
  251.             fprintf(fp, "    ");
  252.         }
  253.         ptr = &sp->s_id[0];
  254.         while (ptr < &sp->s_id[NCPS]) {
  255.             if (c = *ptr++) {
  256.                 putc(c, fp);
  257.             } else {
  258.                 putc(' ', fp);
  259.             }
  260.         }
  261.         if (sp->s_flag & S_ASG) {
  262.             putc('=', fp);
  263.         } else {
  264.             putc(' ', fp);
  265.         }
  266.         if (sp->s_type == S_NEW) {
  267.             if (xflag == 0) {
  268.                 fprintf(fp, "  **** ");
  269.             } else
  270.             if (xflag == 1) {
  271.                 fprintf(fp, "****** ");
  272.             } else
  273.             if (xflag == 2) {
  274.                 fprintf(fp, " ***** ");
  275.             }
  276.         } else {
  277.             j = sp->s_addr;
  278.             if (xflag == 0) {
  279.                 fprintf(fp, "  %04X ", j);
  280.             } else
  281.             if (xflag == 1) {
  282.                 fprintf(fp, "%06o ", j);
  283.             } else
  284.             if (xflag == 2) {
  285.                 fprintf(fp, " %05u ", j);
  286.             }
  287.         }
  288.         j = 0;
  289.         if (sp->s_flag & S_GBL) {
  290.             putc('G', fp);
  291.             ++j;
  292.         }
  293.         if (sp->s_area != NULL) {
  294.             putc('R', fp);
  295.             ++j;
  296.         }
  297.         if (sp->s_type == S_NEW) {
  298.             putc('X', fp);
  299.             ++j;
  300.         }
  301.         if (++i % 3 == 0) {
  302.             putc('\n', fp);
  303.             slew(fp);
  304.         } else
  305.         if (i < nmsym) {
  306.             while (j++ < 4)
  307.                 putc(' ', fp);
  308.             fprintf(fp, "| ");
  309.         }
  310.     }
  311.     putc('\n', fp);
  312.  
  313.     /*
  314.      * Area Table Header
  315.      */
  316.     strcpy(stb, &aretbl[0]);
  317.     lop = NLPP;
  318.     slew(fp);
  319.  
  320.     /*
  321.      * Area Table Output
  322.      */
  323.     narea = 0;
  324.     ap = areap;
  325.     while (ap) {
  326.         ++narea;
  327.         ap = ap->a_ap;
  328.     }
  329.     for (i=0; i<narea; ++i) {
  330.         ap = areap;
  331.         for (j=i+1; j<narea; ++j)
  332.             ap = ap->a_ap;
  333.         j = ap->a_ref;
  334.         if (xflag == 0) {
  335.             fprintf(fp, "  %2X ", j);
  336.         } else
  337.         if (xflag == 1) {
  338.             fprintf(fp, " %3o ", j);
  339.         } else
  340.         if (xflag == 2) {
  341.             fprintf(fp, " %3u ", j);
  342.         }
  343.         ptr = &ap->a_id[0];
  344.         while (ptr < &ap->a_id[NCPS]) {
  345.             if (c = *ptr++) {
  346.                 putc(c, fp);
  347.             } else {
  348.                 putc(' ', fp);
  349.             }
  350.         }
  351.         j = ap->a_size;
  352.         k = ap->a_flag;
  353.         if (xflag==0) {
  354.             fprintf(fp, "   size %4X   flags %X\n", j, k);
  355.         } else
  356.         if (xflag==1) {
  357.             fprintf(fp, "   size %6o   flags %o\n", j, k);
  358.         } else
  359.         if (xflag==2) {
  360.             fprintf(fp, "   size %5u   flags %u\n", j, k);
  361.         }
  362.     }        
  363. }
  364.